\section[Plataforma base]{Plataforma Base de Desenvolvimento}

\begin{frame}
\textbf{Plataforma Base de Desenvolvimento}
\end{frame}


\begin{frame}
\frametitle{Propósito}
\begin{itemize}
  \item Possibilitar a construção de software em linguagem de montagem
  % vantagens, desvantagens e necessidade do desenvolvimento em baixo nível
  \item Desenvolvimento direto ou como produto da compilação
  \item Facilitar a execução de instruções RISCO
  % não precisa recorrer a um dispositivo externo ou a uma especificação do 
  % processador
  \item Consiste de duas ferramentas:
  \begin{description}
    \item[risco-as] Montador da plataforma
    \item[risco-sim] Simulador do processador no ambiente host
  \end{description}
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Montador}
\begin{itemize}
  \item Tradutor da linguagem de montagem para o código binário executável
  % tecnicamente é um compilador, porém mais simples
  \item Representação em alto nível das instruções do RISCO
  \item Provê uma abstração para o compilador:
  % o compilador fica mais enxuto e se foca mais na semântica das instruções em 
  % vez das tarefas mecânicas da geração do executável
  \begin{itemize}
    \item Codificação das instruções
    \item Escolha dos formatos de instrução (5 tipos)
    \item Manipulação de constantes de 32 bits
    \item Cálculo dos endereços de salto (rótulos)
    \item Formato do executável
  \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Montador}
\begin{itemize}
  \item 4 módulos (como um compilador):
  \begin{itemize}
    \item Analisador léxico (\textbf{Flex})
    \item Analisador sintático (\textbf{Bison})
    \item Analisador semântico
    \item Gerador de código
  \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Linguagem de montagem}
\begin{itemize}
  \item Nova linguagem de montagem
  \item Inspirada na sintaxe do Spim (MIPS)
  \item Usa o pré-processador C: constantes, macros, etc.
  \item Elementos léxicos:
  \begin{itemize}
    \item Comentários e símbolos de pontuação
    \item Diretivas de dados ou instruções
    \item Mnemônicos das instruções e apelidos dos registradores
    \item Identificadores alfanuméricos, strings literais e constantes inteiras
  \end{itemize}
\end{itemize}
\end{frame}

% apresentar a gramática na notação EBNF
% simplificação da gramática original, na notação do Bison
% é uma gramática LALR(1)

\begin{frame}[fragile]
\frametitle{Gramática da linguagem de montagem}
\footnotesize
\begin{verbatim}
  <programa>    ::= <declaracoes> <secoes>
  
  <declaracoes> ::= <declaracoes> ".start"  t_identifier | 
                    <declaracoes> ".global" t_identifier |
                    <declaracoes> ".extern" t_identifier | #
                    
  <secoes>      ::= <secoes> <dados> | <secoes> <codigo> | #
  
  <dados> ::= ".data" <diretivas>
  
  <diretivas> ::= <diretivas> ".ascii" t_string_literal |
                  <diretivas> ".word" t_integer |
                  <diretivas> ".byte" t_integer |
                  <diretivas> ".resw" t_integer |
                  <diretivas> ".resb" t_integer | #
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Gramática da linguagem de montagem}
\footnotesize
\begin{verbatim}
  <codigo> ::= ".text" <instrucoes>
  
  <instrucoes> ::=
    <instrucoes> <rotulos> <instrucao> [";"] | #
    
  <rotulos> ::= <rotulos> t_identifier ":" | #
  
  <instrucao> ::=
    <aritmetica_logica> ["!"] <operandos_normais> |
    <salto>             ["!"] <operandos_salto>   |
    <chamada_rotina>    ["!"] <operandos_salto>   |
    <leitura_memoria>   ["!"] <operandos_leitura> |
    <escrita_memoria>   ["!"] <operandos_escrita>
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Gramática da linguagem de montagem}
\footnotesize
\begin{verbatim}
  <operandos_normais> ::=
      t_register "," t_register "," t_register
    | t_register "," t_register "," <constante>
    | t_register "," <constante_estendida>
    
  <operandos_salto> ::=
    t_register | <constante> | <operandos_normais>
    
  <operandos_leitura> ::=
      t_register ","
      "[" <constante> ["+" t_register] "]"
    | t_register ","
      "[" t_register  ["+" (t_register | <constante>)] "]"
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Gramática da linguagem de montagem}
\footnotesize
\begin{verbatim}
  <operandos_escrita> ::=
      "[" <constante> ["+" t_register] "]"
      "," t_register
    | "[" t_register  ["+" (t_register | <constante>)] "]"
      "," t_register
      
  <constante> ::= t_integer | t_identifier
  
  <constante_estendida> ::= ["@"] <constante>
\end{verbatim}
\end{frame}

\begin{frame}[fragile]
\frametitle{Programa em linguagem de montagem}
% calcula o tamanho da string na área de dados
% explicar o processo de cálculo dos rótulos (2 passes)
\tiny
\begin{verbatim}
#include "risco/stdlib.h"
#define cmp(a, b) add! $zero, a, b
#define nop       add $zero, $zero, $zero

.global main

.data
str: .ascii "Hello World!" .byte 0

.text
main:
        add $t1, $zero, $zero    # index
        add $a0, $zero, $zero    # counter
loop:
        ldpoi $t2, [str + $t1]
        cmp ($t2, 0)
        jmpeq out
        nop
        add $a0, $a0, 1
        jmp loop
        nop
out:
        sr print_int
        nop
        add $a0, $zero, $zero
        sr exit
        nop
\end{verbatim}
\end{frame}

\begin{frame}
\frametitle{Funcionalidade de ligador}

\begin{itemize}
  \item O \textbf{risco-as} também faz papel de \emph{ligador}
  % une diferentes unidades de compilação em assembly
  \item Simplificou o desenvolvimento da plataforma
  % mencionar a alternativa: utilização do ELF
  % ferramentas prontas, etc.
  % o risco não necessitava dessa robustez, foi mais rápido codificar o ligador
  % do que aprender a integrar as ferramentas do unix
  \item Diretivas \textbf{.global} e \textbf{.extern}
\end{itemize}

\begin{figure}[htb]
  \centering
  \includegraphics[scale=0.47]{images/ligador-uniao}
\end{figure}

\end{frame}

\begin{frame}
\frametitle{Formato do executável}
\begin{figure}[htb]
  \centering
  \includegraphics[scale=0.65]{images/formato-executavel}
\end{figure}
\end{frame}

\begin{frame}
\frametitle{Simulador}
\begin{itemize}
  \item Necessidade de um dispositivo que execute fielmente as instruções
  geradas. Alternativas:
  \begin{itemize}
    \item Dispositivo real
    \item Especificação executável
    \item \alert{Simulador artificial}
  \end{itemize}
  \item Opções de implementação:
  \begin{itemize}
    \item Execução nativa: tradução para a arquitetura host
    \item \alert{Máquina virtual}: considera as instruções como \emph{bytecodes}
  \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Loop de interpretação}
\tiny
\begin{verbatim}
word reg[NUM_REGISTERS]
byte memory[MEMORY_SIZE];

struct Decoded {
  unsigned opcode;
  bool aps;
  ...
};

decode(unsigned instruction, Decoded& decoded) {
  decoded.opcode = instruction >> 25;
  decoded.aps = instruction & (1 << 24);
  int f1_f0 = (instruction >> 22) & 0x03;
  ...
}

void run() {
  reg[PC_REG] = start_position;
  reg[SP_REG] = MEMORY_SIZE-1;

  while (running) {
    unsigned instr = memory_read(reg[PC_REG]);
    reg[PC_REG] += 4;
    Decoded decoded = decode(instr);
    switch (decoded.opcode) {
      case OP_ADD:
        reg[decoded.dst] = decoded.ft1 + decoded.ft2;
        break;
      ...
    }
    if (decoded.aps) update_psw();
  }
}
\end{verbatim}
\end{frame}


\begin{frame}
\frametitle{Chamadas de sistema}
\begin{itemize}
  \item Nova instrução: \textbf{syscall}
  \item Facilita a depuração das ferramentas
  \item Possibilita interação com o usuário
\end{itemize}

\tiny 

\begin{table}[htb!]
\begin{center}
\begin{tabular}{ c | c | c | c | c }
  \textbf{Nome} & \textbf{Código} & \textbf{Argumentos} & \textbf{Retorno} &
  \textbf{Equivalente em C} \\
  \hline
  
  \texttt{print\_int} & 1 & \texttt{int i} & & \texttt{printf(``\%d'', i)} \\
  
  \texttt{print\_uint} & 2 & \texttt{unsigned int i} & &
  \texttt{printf(``\%u'', i)} \\
  
  \texttt{print\_char} & 3 & \texttt{char c} & & \texttt{printf(``\%c'', c)} \\
  
  \texttt{print\_string} & 4 & \texttt{char* s} & & \texttt{puts(s)} \\
  
  \texttt{read\_int} & 5 & & \texttt{int i} & \texttt{scanf(``\%d'', \&i)} \\
  
  \texttt{read\_char} & 6 & & \texttt{char c} & \texttt{scanf(``\%c'', \&c)} \\
  
  \texttt{read\_string} & 7 & \texttt{char* s; int n} & &
  \texttt{fgets(s,n,STDIN)} \\
  
  \texttt{fopen} & 8 & \texttt{char* f, m} & \texttt{int fd} &
  \texttt{fopen(f,m)} \\
  
  \texttt{fwrite} & 9 & \texttt{char* b; int n, fd} & \texttt{int k} &
  \texttt{fwrite(b,1,n,fd)} \\
  
  \texttt{fread} & 10 & \texttt{char* b; int n, fd} & \texttt{int k} &
  \texttt{fread(b,1,n,fd)} \\
  
  \texttt{fclose} & 11 & \texttt{int fd} & \texttt{int st} &
  \texttt{fclose(fd)} \\
  
  \texttt{malloc} & 12 & \texttt{int n} & \texttt{void* ptr} & 
  \texttt{malloc(n)} \\
  
  \texttt{free} & 13 & \texttt{void* ptr} & & \texttt{free(ptr)} \\
  
  \texttt{exit} & 99 & \texttt{int code} & & \texttt{exit(code)} \\
  
\end{tabular}
\end{center}
\caption{Chamadas de sistema do \texttt{risco-sim}}
\end{table}


\end{frame}
